package com.matrix.framework.core.component;

import com.matrix.framework.sysconfig.token.data.SysConfigPo;
import com.matrix.framework.sysconfig.token.service.SysConfigService;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

/**
 * JWT配置管理器
 * 提供运行时动态更新JWT配置的功能
 * 
 * Copyright © 海平面工作室 版权所有
 *
 * @Author: Leo
 * @Create: 2025/06/23 23:25
 * @Since 1.2
 */
@Component
public class JwtConfigManager {

    private final SysConfigService sysConfigService;

    public JwtConfigManager(SysConfigService sysConfigService) {
        this.sysConfigService = sysConfigService;
    }

    /**
     * 重新加载JWT配置
     */
    public Mono<Void> reloadJwtConfig() {
        return loadJwtExpiration()
                .then(loadRefreshThreshold())
                .doOnSuccess(unused -> System.out.println("JWT配置重新加载完成"))
                .doOnError(error -> System.err.println("JWT配置重新加载失败: " + error.getMessage()));
    }

    /**
     * 更新JWT过期时间配置
     */
    public Mono<Void> updateJwtExpiration(long expirationMinutes) {
        return sysConfigService.getConfigValue("JWT", "EXPIRATION")
                .switchIfEmpty(Mono.just("30"))
                .flatMap(currentValue -> {
                    if (!String.valueOf(expirationMinutes).equals(currentValue)) {
                        // 如果配置值有变化，更新数据库中的配置
                        return sysConfigService.save(createConfigPo("JWT", "EXPIRATION", 
                                String.valueOf(expirationMinutes), "JWT过期时间"))
                                .then();
                    }
                    return Mono.empty();
                })
                .doOnSuccess(unused -> {
                    Jwt.setJwtExpiration(expirationMinutes);
                    System.out.println("JWT过期时间已更新为: " + expirationMinutes + " 分钟");
                });
    }

    /**
     * 更新JWT刷新阈值配置
     */
    public Mono<Void> updateRefreshThreshold(long thresholdMinutes) {
        return sysConfigService.getConfigValue("JWT", "REFRESH_THRESHOLD")
                .switchIfEmpty(Mono.just("10"))
                .flatMap(currentValue -> {
                    if (!String.valueOf(thresholdMinutes).equals(currentValue)) {
                        // 如果配置值有变化，更新数据库中的配置
                        return sysConfigService.save(createConfigPo("JWT", "REFRESH_THRESHOLD", 
                                String.valueOf(thresholdMinutes), "自动续期阈值时间"))
                                .then();
                    }
                    return Mono.empty();
                })
                .doOnSuccess(unused -> {
                    Jwt.setRefreshThreshold(thresholdMinutes);
                    System.out.println("JWT刷新阈值已更新为: " + thresholdMinutes + " 分钟");
                });
    }

    /**
     * 获取当前JWT过期时间配置（分钟）
     */
    public long getCurrentJwtExpirationMinutes() {
        return Jwt.JWT_EXPIRATION / (60 * 1000);
    }

    /**
     * 获取当前JWT刷新阈值配置（分钟）
     */
    public long getCurrentRefreshThresholdMinutes() {
        return Jwt.REFRESH_THRESHOLD / (60 * 1000);
    }

    /**
     * 从数据库加载JWT过期时间配置
     */
    private Mono<Void> loadJwtExpiration() {
        return sysConfigService.getConfigValue("JWT", "EXPIRATION")
                .switchIfEmpty(Mono.just("30"))
                .doOnNext(value -> {
                    try {
                        long expirationMinutes = Long.parseLong(value);
                        Jwt.setJwtExpiration(expirationMinutes);
                        System.out.println("JWT过期时间重新加载为: " + expirationMinutes + " 分钟");
                    } catch (NumberFormatException e) {
                        System.err.println("JWT过期时间配置值无效，使用默认值30分钟: " + value);
                        Jwt.setJwtExpiration(30);
                    }
                })
                .onErrorResume(error -> {
                    System.err.println("重新加载JWT过期时间配置失败，使用默认值30分钟: " + error.getMessage());
                    Jwt.setJwtExpiration(30);
                    return Mono.just("30");
                })
                .then();
    }

    /**
     * 从数据库加载JWT刷新阈值配置
     */
    private Mono<Void> loadRefreshThreshold() {
        return sysConfigService.getConfigValue("JWT", "REFRESH_THRESHOLD")
                .switchIfEmpty(Mono.just("10"))
                .doOnNext(value -> {
                    try {
                        long thresholdMinutes = Long.parseLong(value);
                        Jwt.setRefreshThreshold(thresholdMinutes);
                        System.out.println("JWT刷新阈值重新加载为: " + thresholdMinutes + " 分钟");
                    } catch (NumberFormatException e) {
                        System.err.println("JWT刷新阈值配置值无效，使用默认值10分钟: " + value);
                        Jwt.setRefreshThreshold(10);
                    }
                })
                .onErrorResume(error -> {
                    System.err.println("重新加载JWT刷新阈值配置失败，使用默认值10分钟: " + error.getMessage());
                    Jwt.setRefreshThreshold(10);
                    return Mono.just("10");
                })
                .then();
    }

    /**
     * 创建配置Po对象
     */
    private SysConfigPo createConfigPo(String sort, String key, String value, String memo) {
        SysConfigPo config = new SysConfigPo();
        config.setSort(sort);
        config.setKey(key);
        config.setValue(value);
        config.setMemo(memo);
        return config;
    }
} 